home *** CD-ROM | disk | FTP | other *** search
/ Freelog 115 / FreelogNo115-MaiJuin2013.iso / Internet / Filezilla Server / FileZilla_Server-0_9_41.exe / source / SpeedLimit.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2012-02-22  |  7.1 KB  |  359 lines
  1. // FileZilla Server - a Windows ftp server
  2.  
  3. // Copyright (C) 2002-2004 - Tim Kosse <tim.kosse@gmx.de>
  4.  
  5. // This program is free software; you can redistribute it and/or
  6. // modify it under the terms of the GNU General Public License
  7. // as published by the Free Software Foundation; either version 2
  8. // of the License, or (at your option) any later version.
  9.  
  10. // This program is distributed in the hope that it will be useful,
  11. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. // GNU General Public License for more details.
  14.  
  15. // You should have received a copy of the GNU General Public License
  16. // along with this program; if not, write to the Free Software
  17. // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  
  19. // Speedcpp: implementation of the CSpeedLimit class.
  20. //
  21. //////////////////////////////////////////////////////////////////////
  22.  
  23. #include "stdafx.h"
  24. #include "SpeedLimit.h"
  25. #include "xml_utils.h"
  26. #include "tinyxml/tinyxml.h"
  27.  
  28. //////////////////////////////////////////////////////////////////////
  29. // Construction/Destruction
  30. //////////////////////////////////////////////////////////////////////
  31.  
  32. CSpeedLimit::CSpeedLimit()
  33. {
  34.     m_Day = 0;
  35.  
  36.     m_Speed = 10;
  37.     m_ToCheck = false;
  38.     m_DateCheck = false;
  39.     m_FromCheck = false;
  40. }
  41.  
  42. CSpeedLimit::~CSpeedLimit()
  43. {
  44.  
  45. }
  46.  
  47. bool CSpeedLimit::IsItActive(const SYSTEMTIME &time) const
  48. {
  49.     if (m_DateCheck)
  50.     {
  51.         if ((m_Date.y != time.wYear) ||
  52.             (m_Date.m != time.wMonth) ||
  53.             (m_Date.d != time.wDay))
  54.             return false;
  55.     }
  56.     else
  57.     {
  58.         int i = (time.wDayOfWeek + 6) % 7;
  59.         
  60.         if (!(m_Day & ( 1 << i)))
  61.             return false;
  62.     }
  63.  
  64.     int curTime = time.wHour * 60 * 60 +
  65.                   time.wMinute * 60 +
  66.                   time.wSecond;
  67.  
  68.     int fromTime = 0;
  69.     int toTime = 0;
  70.     if (m_ToCheck)
  71.         toTime = m_ToTime.h * 60 * 60 +
  72.                  m_ToTime.m * 60 +
  73.                  m_ToTime.s;
  74.     if (m_FromCheck)
  75.         fromTime = m_FromTime.h * 60 * 60 +
  76.                    m_FromTime.m * 60 +
  77.                    m_FromTime.s;
  78.  
  79.     if (m_FromCheck && m_ToCheck)
  80.     {
  81.         int span = toTime - fromTime;
  82.         if (span < 0)
  83.             span += 24 * 60 * 60;
  84.         int ref = curTime - fromTime;
  85.         if (ref < 0)
  86.             ref += 24 * 60 * 60;
  87.         if (span < ref)
  88.             return false;
  89.     }
  90.     else
  91.     {
  92.         if (m_ToCheck)
  93.         {
  94.             if (toTime < curTime)
  95.                 return false;
  96.         }
  97.  
  98.         if (m_FromCheck)
  99.         {
  100.             if (fromTime > curTime)
  101.                 return false;
  102.         }
  103.     }
  104.  
  105.     return true;
  106. }
  107.  
  108. int CSpeedLimit::GetRequiredBufferLen() const
  109. {
  110.     return    4 + //Speed
  111.             4 + //date
  112.             6 +    //2 * time
  113.             1;  //Weekday
  114.     
  115. }
  116.  
  117. char * CSpeedLimit::FillBuffer(char *p) const
  118. {
  119.     *p++ = m_Speed >> 24;
  120.     *p++ = (m_Speed >> 16) % 256;
  121.     *p++ = (m_Speed >> 8) % 256;
  122.     *p++ = m_Speed % 256;
  123.  
  124.     if (m_DateCheck)
  125.     {
  126.         *p++ = m_Date.y >> 8;
  127.         *p++ = m_Date.y % 256;
  128.         *p++ = m_Date.m;
  129.         *p++ = m_Date.d;
  130.     }
  131.     else
  132.     {
  133.         memset(p, 0, 4);
  134.         p += 4;
  135.     }
  136.     
  137.     if (m_FromCheck)
  138.     {
  139.         *p++ = m_FromTime.h;
  140.         *p++ = m_FromTime.m;
  141.         *p++ = m_FromTime.s;
  142.     }
  143.     else
  144.     {
  145.         memset(p, 0, 3);
  146.         p += 3;
  147.     }
  148.  
  149.     if (m_ToCheck)
  150.     {
  151.         *p++ = m_ToTime.h;
  152.         *p++ = m_ToTime.m;
  153.         *p++ = m_ToTime.s;
  154.     }
  155.     else
  156.     {
  157.         memset(p, 0, 3);
  158.         p += 3;
  159.     }
  160.  
  161.     *p++ = m_Day;
  162.     
  163.     return p;
  164. }
  165.  
  166. unsigned char * CSpeedLimit::ParseBuffer(unsigned char *pBuffer, int length)
  167. {
  168.     if (length < GetRequiredBufferLen())
  169.         return 0;
  170.  
  171.     unsigned char *p = pBuffer;
  172.  
  173.     m_Speed = *p++ << 24;
  174.     m_Speed |= *p++ << 16;
  175.     m_Speed |= *p++ << 8;
  176.     m_Speed |= *p++;
  177.     
  178.     if (m_Speed > 1048576)
  179.         m_Speed = 1048576;
  180.  
  181.     char tmp[4] = {0};
  182.  
  183.     if (memcmp(p, tmp, 4))    
  184.     {
  185.         m_DateCheck = true;
  186.         m_Date.y = *p++ << 8;
  187.         m_Date.y |= *p++;
  188.         m_Date.m = *p++;
  189.         m_Date.d = *p++;
  190.         if (m_Date.y < 1900 || m_Date.y > 3000 || m_Date.m < 1 || m_Date.m > 12 || m_Date.d < 1 || m_Date.d > 31)
  191.             return false;
  192.     }
  193.     else
  194.     {
  195.         p += 4;
  196.         m_DateCheck = false;
  197.     }
  198.     
  199.     if (memcmp(p, tmp, 3))    
  200.     {
  201.         m_FromCheck = true;
  202.         m_FromTime.h = *p++;
  203.         m_FromTime.m = *p++;
  204.         m_FromTime.s = *p++;
  205.         if (m_FromTime.h > 23 || m_FromTime.m > 59 || m_FromTime.s > 59)
  206.             return false;
  207.     }
  208.     else
  209.     {
  210.         p += 3;
  211.         m_FromCheck = false;
  212.     }
  213.  
  214.     if (memcmp(p, tmp, 3))    
  215.     {
  216.         m_ToCheck = TRUE;
  217.         m_ToTime.h = *p++;
  218.         m_ToTime.m = *p++;
  219.         m_ToTime.s = *p++;
  220.         if (m_ToTime.h > 23 || m_ToTime.m > 59 || m_ToTime.s > 59)
  221.             return false;
  222.     }
  223.     else
  224.     {
  225.         p += 3;
  226.         m_ToCheck = false;
  227.     }
  228.  
  229.     m_Day = *p++;
  230.  
  231.     return p;
  232. }
  233.  
  234. static void SaveTime(TiXmlElement* pElement, CSpeedLimit::t_time t)
  235. {
  236.     pElement->SetAttribute("Hour", t.h);
  237.     pElement->SetAttribute("Minute", t.m);
  238.     pElement->SetAttribute("Second", t.s);
  239. }
  240.  
  241. void CSpeedLimit::Save(TiXmlElement* pElement)
  242. {
  243.     pElement->SetAttribute("Speed", m_Speed);
  244.  
  245.     CStdString str;
  246.     str.Format(_T("%d"), m_Day);
  247.     TiXmlElement* pDays = pElement->LinkEndChild(new TiXmlElement("Days"))->ToElement();
  248.     XML::SetText(pDays, str);
  249.  
  250.     if (m_DateCheck)
  251.     {
  252.         TiXmlElement* pDate = pElement->LinkEndChild(new TiXmlElement("Date"))->ToElement();
  253.         pDate->SetAttribute("Year", m_Date.y);
  254.         pDate->SetAttribute("Month", m_Date.m);
  255.         pDate->SetAttribute("Day", m_Date.d);
  256.     }
  257.  
  258.     if (m_FromCheck)
  259.     {
  260.         TiXmlElement* pFrom = pElement->LinkEndChild(new TiXmlElement("From"))->ToElement();
  261.         SaveTime(pFrom, m_FromTime);
  262.     }
  263.  
  264.     if (m_ToCheck)
  265.     {
  266.         TiXmlElement* pTo = pElement->LinkEndChild(new TiXmlElement("To"))->ToElement();
  267.         SaveTime(pTo, m_ToTime);
  268.     }
  269. }
  270.  
  271. CSpeedLimit::t_time CSpeedLimit::ReadTime(TiXmlElement* pElement)
  272. {
  273.     CSpeedLimit::t_time t;
  274.  
  275.     CStdString str = ConvFromNetwork(pElement->Attribute("Hour"));
  276.     int n = _ttoi(str);
  277.     if (n < 0 || n > 23)
  278.         n = 0;
  279.     t.h = n;
  280.     str = ConvFromNetwork(pElement->Attribute("Minute"));
  281.     n = _ttoi(str);
  282.     if (n < 0 || n > 59)
  283.         n = 0;
  284.     t.m = n;
  285.     str = ConvFromNetwork(pElement->Attribute("Second"));
  286.     n = _ttoi(str);
  287.     if (n < 0 || n > 59)
  288.         n = 0;
  289.     t.s = n;
  290.  
  291.     return t;
  292. }
  293.  
  294. bool CSpeedLimit::Load(TiXmlElement* pElement)
  295. {
  296.     CStdString str;
  297.     str = ConvFromNetwork(pElement->Attribute("Speed"));
  298.     int n = _ttoi(str);
  299.     if (n < 0)
  300.         n = 0;
  301.     else if (n > 1048576)
  302.         n = 1048576;
  303.     m_Speed = n;
  304.  
  305.     TiXmlElement* pDays = pElement->FirstChildElement("Days");
  306.     if (pDays)
  307.     {
  308.         str = XML::ReadText(pDays);
  309.         if (str != _T(""))
  310.             n = _ttoi(str);
  311.         else
  312.             n = 0x7F;
  313.         m_Day = n & 0x7F;
  314.     }
  315.  
  316.     m_DateCheck = false;
  317.  
  318.     TiXmlElement* pDate = pElement->FirstChildElement("Date");
  319.     if (pDate)
  320.     {
  321.         m_DateCheck = true;
  322.         str = ConvFromNetwork(pDate->Attribute("Year"));
  323.         n = _ttoi(str);
  324.         if (n < 1900 || n > 3000)
  325.             n = 2003;
  326.         m_Date.y = n;
  327.         str = ConvFromNetwork(pDate->Attribute("Month"));
  328.         n = _ttoi(str);
  329.         if (n < 1 || n > 12)
  330.             n = 1;
  331.         m_Date.m = n;
  332.         str = ConvFromNetwork(pDate->Attribute("Day"));
  333.         n = _ttoi(str);
  334.         if (n < 1 || n > 31)
  335.             n = 1;
  336.         m_Date.d = n;
  337.     }
  338.  
  339.     TiXmlElement* pFrom = pElement->FirstChildElement("From");
  340.     if (pFrom)
  341.     {
  342.         m_FromCheck = true;
  343.         m_FromTime = ReadTime(pFrom);
  344.     }
  345.     else
  346.         m_FromCheck = false;
  347.  
  348.     TiXmlElement* pTo = pElement->FirstChildElement("To");
  349.     if (pTo)
  350.     {
  351.         m_ToCheck = true;
  352.         m_ToTime = ReadTime(pTo);
  353.     }
  354.     else
  355.         m_ToCheck = false;
  356.  
  357.     return true;
  358. }
  359.